package edu.szcu.cstms_admin.dao;

import edu.szcu.cstms_admin.entity.UserInfo;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.jdbc.SQL;

import java.util.List;
import java.util.Map;

/**
 * 用户信息数据访问接口
 */
@Mapper
public interface UserInfoDao {

    /**
     * 插入用户信息
     *
     * @param userInfo 用户信息对象
     * @return 影响的行数
     */
    @Insert("INSERT INTO `user_info`(student_worker_id, name, gender, college, contact, email, password, register_time, create_time, update_time) " +
            "VALUES(#{studentWorkerId}, #{name}, #{gender}, #{college}, #{contact}, #{email}, #{password}, #{registerTime}, NOW(), NOW())")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(UserInfo userInfo);

    /**
     * 根据ID查询用户信息
     *
     * @param id 用户ID
     * @return 用户信息对象
     */
    @Select("SELECT * FROM `user_info` WHERE id = #{id}")
    UserInfo selectById(Long id);

    /**
     * 根据学号/工号查询用户信息
     *
     * @param studentWorkerId 学号/工号
     * @return 用户信息对象
     */
    @Select("SELECT * FROM `user_info` WHERE student_worker_id = #{studentWorkerId}")
    UserInfo selectByStudentWorkerId(String studentWorkerId);

    /**
     * 根据姓名精确查询用户信息
     *
     * @param name 用户姓名
     * @return 用户信息对象
     */
    @Select("SELECT * FROM `user_info` WHERE name = #{name}")
    UserInfo selectByName(String name);

    /**
     * 根据姓名模糊查询用户信息
     *
     * @param name 用户姓名关键字
     * @return 用户信息列表
     */
    @SuppressWarnings("unused")
    @Select("SELECT * FROM `user_info` WHERE name LIKE CONCAT('%', #{name}, '%')")
    List<UserInfo> selectByNameLike(String name);

    /**
     * 根据学号/工号和密码查询用户信息（用于登录验证）
     *
     * @param studentWorkerId 学号/工号
     * @param password 密码
     * @return 用户信息
     */
    @Select("SELECT * FROM `user_info` WHERE student_worker_id = #{studentWorkerId} AND password = #{password}")
    UserInfo selectByStudentWorkerIdAndPassword(@Param("studentWorkerId") String studentWorkerId, @Param("password") String password);

    /**
     * 查询所有用户信息
     *
     * @return 用户信息列表
     */
    @Select("SELECT * FROM `user_info`")
    List<UserInfo> selectAll();

    /**
     * 分页查询用户信息
     *
     * @param offset 偏移量
     * @param limit 限制数量
     * @return 用户信息列表
     */
    @Select("SELECT * FROM `user_info` LIMIT #{offset}, #{limit}")
    List<UserInfo> selectByPage(@Param("offset") int offset, @Param("limit") int limit);

    /**
     * 根据学院查询用户信息
     *
     * @param college 学院
     * @return 用户信息列表
     */
    @Select("SELECT * FROM `user_info` WHERE college = #{college}")
    List<UserInfo> selectByCollege(String college);

    /**
     * 根据性别查询用户信息
     *
     * @param gender 性别（1为男，2为女）
     * @return 用户信息列表
     */
    @Select("SELECT * FROM `user_info` WHERE gender = #{gender}")
    List<UserInfo> selectByGender(Integer gender);

    /**
     * 更新用户信息
     *
     * @param userInfo 用户信息对象
     * @return 影响的行数
     */
    @Update("UPDATE `user_info` SET student_worker_id = #{studentWorkerId}, name = #{name}, " +
            "gender = #{gender}, college = #{college}, contact = #{contact}, " +
            "email = #{email}, password = #{password}, update_time = NOW() WHERE id = #{id}")
    int update(UserInfo userInfo);

    /**
     * 更新用户密码
     *
     * @param id 用户ID
     * @param password 新密码
     * @return 影响的行数
     */
    @Update("UPDATE `user_info` SET password = #{password}, update_time = NOW() WHERE id = #{id}")
    int updatePassword(@Param("id") Long id, @Param("password") String password);

    /**
     * 根据ID删除用户信息
     *
     * @param id 用户ID
     * @return 影响的行数
     */
    @Delete("DELETE FROM `user_info` WHERE id = #{id}")
    int deleteById(Long id);

    /**
     * 根据学号/工号删除用户信息
     *
     * @param studentWorkerId 学号/工号
     * @return 影响的行数
     */
    @Delete("DELETE FROM `user_info` WHERE student_worker_id = #{studentWorkerId}")
    int deleteByStudentWorkerId(String studentWorkerId);

    /**
     * 批量删除用户信息
     *
     * @param ids 用户ID列表
     * @return 影响的行数
     */
    @DeleteProvider(type = UserInfoSqlProvider.class, method = "batchDelete")
    int batchDelete(@Param("ids") List<Long> ids);

    /**
     * 统计用户总数
     *
     * @return 用户总数
     */
    @Select("SELECT COUNT(*) FROM `user_info`")
    int count();

    /**
     * 根据学院统计用户数量
     *
     * @param college 学院
     * @return 用户数量
     */
    @Select("SELECT COUNT(*) FROM `user_info` WHERE college = #{college}")
    int countByCollege(String college);

    /**
     * 根据性别统计用户数量
     *
     * @param gender 性别（1为男，2为女）
     * @return 用户数量
     */
    @Select("SELECT COUNT(*) FROM `user_info` WHERE gender = #{gender}")
    int countByGender(Integer gender);

    /**
     * 根据条件查询用户信息
     *
     * @param userInfo 包含查询条件的用户信息对象
     * @return 用户信息列表
     */
    @SelectProvider(type = UserInfoSqlProvider.class, method = "selectByCondition")
    List<UserInfo> selectByCondition(UserInfo userInfo);
    
    /**
     * 根据条件分页查询用户信息
     *
     * @param userInfo 包含查询条件的用户信息对象
     * @param offset 偏移量
     * @param limit 限制数量
     * @return 用户信息列表
     */
    @SelectProvider(type = UserInfoSqlProvider.class, method = "selectByConditionWithPage")
    List<UserInfo> selectByConditionWithPage(@Param("userInfo") UserInfo userInfo, @Param("offset") int offset, @Param("limit") int limit);

    /**
     * 用户信息SQL提供者，用于动态SQL
     */
    class UserInfoSqlProvider {
        /**
         * 根据条件生成查询SQL
         *
         * @param userInfo 包含查询条件的用户信息对象
         * @return 查询SQL
         */
        public String selectByCondition(UserInfo userInfo) {
            return new SQL() {{
                SELECT("*");
                FROM("`user_info`");
                
                if (userInfo.getId() != null) {
                    WHERE("id = #{id}");
                }
                
                if (userInfo.getStudentWorkerId() != null && !userInfo.getStudentWorkerId().isEmpty()) {
                    WHERE("student_worker_id = #{studentWorkerId}");
                }

                if (userInfo.getName() != null && !userInfo.getName().isEmpty()) {
                    WHERE("name LIKE CONCAT('%', #{name}, '%')");
                }

                if (userInfo.getGender() != null) {
                    WHERE("gender = #{gender}");
                }

                if (userInfo.getCollege() != null && !userInfo.getCollege().isEmpty()) {
                    WHERE("college = #{college}");
                }
                
                if (userInfo.getContact() != null && !userInfo.getContact().isEmpty()) {
                    WHERE("contact = #{contact}");
                }

                if (userInfo.getEmail() != null && !userInfo.getEmail().isEmpty()) {
                    WHERE("email = #{email}");
                }
                
                // 注意：通常不建议使用密码作为查询条件，这里仅为完整性添加
                // 在实际应用中，密码应该是加密存储的，不应该用于普通查询
                if (userInfo.getPassword() != null && !userInfo.getPassword().isEmpty()) {
                    WHERE("password = #{password}");
                }
                
                if (userInfo.getRegisterTime() != null) {
                    WHERE("register_time = #{registerTime}");
                }
            }}.toString();
        }
        
        /**
         * 根据条件生成分页查询SQL
         *
         * @param params 包含查询条件和分页参数的Map
         * @return 查询SQL
         */
        public String selectByConditionWithPage(Map<String, Object> params) {
            UserInfo userInfo = (UserInfo) params.get("userInfo");
            
            return new SQL() {{
                SELECT("*");
                FROM("`user_info`");
                
                if (userInfo.getId() != null) {
                    WHERE("id = #{userInfo.id}");
                }
                
                if (userInfo.getStudentWorkerId() != null && !userInfo.getStudentWorkerId().isEmpty()) {
                    WHERE("student_worker_id = #{userInfo.studentWorkerId}");
                }

                if (userInfo.getName() != null && !userInfo.getName().isEmpty()) {
                    WHERE("name LIKE CONCAT('%', #{userInfo.name}, '%')");
                }

                if (userInfo.getGender() != null) {
                    WHERE("gender = #{userInfo.gender}");
                }

                if (userInfo.getCollege() != null && !userInfo.getCollege().isEmpty()) {
                    WHERE("college = #{userInfo.college}");
                }
                
                if (userInfo.getContact() != null && !userInfo.getContact().isEmpty()) {
                    WHERE("contact = #{userInfo.contact}");
                }

                if (userInfo.getEmail() != null && !userInfo.getEmail().isEmpty()) {
                    WHERE("email = #{userInfo.email}");
                }
            }}.toString() + " LIMIT #{offset}, #{limit}";
        }
        
        /**
         * 生成批量删除SQL
         *
         * @param params 包含ids参数的Map
         * @return 批量删除SQL
         */
        public String batchDelete(Map<String, Object> params) {
            List<Long> ids = (List<Long>) params.get("ids");
            StringBuilder sql = new StringBuilder();
            sql.append("DELETE FROM `user_info` WHERE id IN (");
            
            for (int i = 0; i < ids.size(); i++) {
                if (i > 0) {
                    sql.append(",");
                }
                sql.append("#{ids[").append(i).append("]}");
            }
            
            sql.append(")");
            return sql.toString();
        }
    }
}
